//----------------------------------------------------------------------------------------------------------
//Not used! The new plan of the project does not require high speed strings.
//----------------------------------------------------------------------------------------------------------
/*
#pragma once
#include "BuiltInTypes.h"
#include <iostream> //So I can overload the export operator to work with console

//--------------------------------------------------------------------------------------------------------
//re::core::String - Basic string type. Used for high speed string managment.
//--------------------------------------------------------------------------------------------------------
//WHY? The default string library is using 28 bytes, and is giving full information about the cm process
//making it unsuitable for games.
//------------------------------------------------------
namespace re
{
	namespace core
	{
		template<class T>
		class String
		{
		public:
			//---------------------------------------------------------------------------
			//Consturctors and Destructors
			//---------------------------------------------------------------------------
			String()
			{
				allocated_ = 0;
				used_ = 0;
				string_ = 0;
				MakeRoom(kDefaultAllocated);
			}
			String(const char * const str)
			{
				allocated_ = 0;
				used_ = 0;
				string_ = NULL;
				U32 stringlen = strlen(str);
				MakeRoom(stringlen + 1);
#pragma warning(suppress: 6387)
				memcpy(string_, str, stringlen + 1);
			}
			String(const String & str)
			{
				allocated_ = 0;
				used_ = 0;
				string_ = 0;
				MakeRoom(str.used_);
				memcpy(string_, str.string_, str.used_);
			}
			~String()
			{
				if(string_ != NULL)
					delete [] string_;
				allocated_ = 0;
				used_ = 0;
			}
			//---------------------------------------------------------------------------
			//Operator Overloads
			//---------------------------------------------------------------------------
			String<T>& operator=(const String<T> & str)
			{
				if(!Compare(str))
				{
					MakeRoom(str.used_);
					memcpy(string_, str.string_, str.used_);
				}
				return *this;
			}
			char& operator[](const T pos)
			{
				return string_[pos];
			}
			//String<T>& operator=(const char * const str)
			//{
			//	String<T> string(str);
			//	if(!Compare(string))
			//	{
			//		Manage(string.used_);
			//		memcpy(string_, string.string_, string.used_);
			//	}
			//	return *this;
			//}
			bool operator == (const String<T> & str) const
			{
				return Compare(str);
			}
			bool operator < (const String<T> & str) const
			{
				for(T i = 0; i < used_ && i < str.used_; ++i)
				{
						if(chrlowcs(string_[i]) < chrlowcs(str.string_[i]))
						{
							return true;
						}else if(chrlowcs(string_[i]) > chrlowcs(str.string_[i]))
						{
							return false;
						}
				}
				return false;
			}
			bool operator > (const String<T> & str) const
			{
				for(T i = 0; i < used_ && i < str.used_; ++i)
				{
					if(chrlowcs(string_[i]) > chrlowcs(str.string_[i]))
					{
						return true;
					}else if(chrlowcs(string_[i]) < chrlowcs(str.string_[i]))
					{
						return false;
					}
				}
				return true;
			}
			bool operator != (const String<T> & str) const
			{
				return !Compare(str);
			}
			//---------------------------------------------------------------------------
			//Compare Functions
			//---------------------------------------------------------------------------
			bool FastCompare(const String<T> & str)
			{
				if(used_ != str.used_)
				{
					return false;
				}
				for(int i = 0; i < used_; i+=2)
				{
					if(string_[i] != str.string_[i])
					{
						return false;
					}
				}
				return true;
			}
			bool Compare(const String<T> & str)
			{
				if(used_ != str.used_)
				{
					return false;
				}
				for(int i = 0; i < used_; ++i)
				{
					if(string_[i] != str.string_[i])
					{
						return false;
					}
				}
				return true;
			}
			//---------------------------------------------------------------------------
			//Find Functions
			//---------------------------------------------------------------------------
			bool Find(T start, String<T> & str, T found)
			{
				if(str.used_ == 0)
				{
					found = 0;
					return false;
				}
				T i = start;
				T u = 0;
				while(i != used_)
				{
					if(string_[i] == str.string_[u])
					{
						++u;
						if(u == str.used_)
						{
							found = i - u;
							return true;
						}
					}else
					{
						u = 0;
					}
					++i;
				}
				found = 0;
				return false;
			}
			//---------------------------------------------------------------------------
			//String manipulation
			//---------------------------------------------------------------------------
			String<T> Substr(T start, T len)
			{
				String<T> str; T c = 0;
				for(; start < len; ++start)
				{
					str[c] = string_[start];
				}
			};
			void Substr(T start, T len, String<T>& str)
			{
				T c = 0;
				for(; start < len; ++start)
				{
					str.string_[c] = string_[start];
				}
			};
			//---------------------------------------------------------------------------
			//General Functions
			//---------------------------------------------------------------------------
			const char * const c_str()
			{
				return string_;
			}
			wchar_t * create_wstr()
			{
				wchar_t * str = new wchar_t[used_];
#pragma warning(suppress: 4996)
				mbstowcs(str, string_, used_);
				return str;
			}
			T get_len()
			{
				return used_ - 1;
			}

			static U32 strlen(const char * const str)
			{
				U32 count = 0;
				while(str[count] != '\0')
				{
					++count;
				}
				return count;
			}
			static char chrlowcs(char c)
			{ //TODO: FIX THIS
				return c;
			}
			//---------------------------------------------------------------------------
			//Iterator Support
			//---------------------------------------------------------------------------
			class Iterator
			{
			public:
				Iterator() { current_position_ = NULL; }
				Iterator(const char * start, const char * pos) : start_(start), current_position_(pos) {}
				~Iterator() {}
				
				S32 operator-(const Iterator& iter)
				{
					if(start_ != iter.start_)
					{
						return -1;
					}
					return current_position_ - iter.current_position_;
				}
				Iterator& operator=(const Iterator& iter)
				{
					current_position_ = iter.current_position_;
					start_ = iter.start_;
					return *this;
				}
				bool operator==(const Iterator& iter) const
				{
					if(start_ != iter.start_)
					{
						return false;
					}
					if(current_position_ == iter.current_position_)
					{
						return true;
					}
					return false;
				}
				char* operator*()
				{
					return current_position_;
				}
				Iterator& operator++()
				{
					if(current_position_ != NULL && *current_position_ != '\0')
					{
						++current_position_;
					}
				}
				Iterator operator++(int)
				{
					if(current_position_ != NULL && *current_position_ != '\0')
					{
						++current_position_;
					}
					return Iterator(current_position_ - 1);
				}
				Iterator& operator--()
				{
					if(current_position_ != NULL && current_position_ != start_)
					{
						--current_position_;
					}
				}
				Iterator operator--(int)
				{
					if(current_position_ != NULL && current_position_ != start)
					{
						--current_position_;
					}
					return Iterator(current_position_ + 1);
				}
			protected:
				char* current_position_;
				char* start_;
			};
			void Assign(const Iterator& begin, const Iterator& end)
			{
				S32 bytes = end - begin;
				if(bytes <= 0)
				{
					return; // throw error;
				}
				Manage(bytes + 1);
				memcpy(string_, begin.current_position_, bytes + 1);
			}
			Iterator Begin()
			{
				return Iterator(start_, start_);
			}
			Iterator End()
			{
				return Iterator(start_, start_ + used_);
			}
			//---------------------------------------------------------------------------
			//Private Functions
			//---------------------------------------------------------------------------
		private:
			void MakeRoom(T bytes)
			{
				if(bytes == 0)
				{
					used_ = 0;
					allocated_ = 0;
					if(string_ != NULL)
					{
						delete [] string_;
					}
					string_ = 0;
					return;
				}
				if(allocated_ < bytes)
				{
					char * container = new char[bytes];
					if(string_ != NULL)
					{
						delete [] string_;
					}
					string_ = container;
					allocated_ = bytes;
				}
				used_ = bytes;
			}
			//---------------------------------------------------------------------------
			//Member Variables
			//---------------------------------------------------------------------------
			char * string_; // the string itself(or the beginning of it :)
			T allocated_; // how much symbols can be stored without new allocations?
			T used_; // how many of the symbols are beeing used. /0 included
			static const U32 kDefaultAllocated;
		};
		//typedef String<U8> TinyString;//sizeof(TinyString) == sizeof(ShortString) -> True -> TinyString = Useless
		typedef String<re::core::U16> RegularString;
		typedef String<re::core::U32> LongString;
		//typedef String<U16,S16> RegularWString;
		//typedef String<U32,S16> LongWString;
	}
}
*/